<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

</body>
<script>
    {
        // 1- Promise是一个构造函数
        // 2- Promise构造函数接收一个回调函数（执行器函数），该执行器函数是同步执行的
        // 3- 执行器函数接收两个参数（resolve,reject），两个参数的类型是函数。
        // 4- 通过构造函数Promise生成的实例称为Promise实例
        // 5- Promise实例中拥有值，还有状态两个属性
        // 6- 状态分为三种：pending,fulfilled,rejected
        // 7- 状态初始值为pending
        // 8- 状态只会被更改一次：
        //    要么是从pending更改为fulfilled
        //        通过调用resolve函数，函数接收的值称为成功值
        //    要么是从pending更改为rejected
        //        通过调用reject函数，函数接收的值称为失败值
        //        通过抛出异常，状态为失败，异常信息为失败值
        // const p = new Promise(function(resolve,reject){
        //     // resolve(1);// 将p的状态设置为成功，值为1
        //     // reject(2);// 失败，2
        //
        //     // 抛出异常
        //     // throw "异常";// 失败，值为 异常
        //
        //     // let a = 1;
        //     // a();
        //     console.log(11111)
        // });
        // console.log(p);
        // console.log(22222)
    }
    {
        // 2- Promise实例的原型中拥有方法then，catch
        // 2-1 then函数接收两个参数（类型均为函数），第一个参数称为成功回调，第二个参数称为失败回调
        // 2-2 当p的状态为成功执行成功回调，p的状态为失败执行失败回调。
        // 2-3 成功回调接收的参数是成功值，失败回调接收的参数是失败值。
        // 2-4 可以先更改状态，再指定回调函数，也可以先指定回调函数再更改状态。
        // 2-5 可以多次调用then。都会执行
        // 2-6 then的返回值是一个Promise实例，实例的状态以及值受成功或失败回调函数的返回值的影响。
        //     如果回调函数返回的是一个非Promise实例，那么得到 的状态为成功，值为返回值
        //     如果返回的是一个Promise实例，那么得到的状态以及值与返回的实例相同。
        //     如果回调函数有异常，那么得到的状态为失败，值为异常信息
        // 2-7- then指定的回调函数为异步调用。
        // 2-8- 如果省略成功回调，默认成功回调为v=>v;如果省略失败回调，相当于：reason=>{throw reason}
        // 2-9- 链式调用
        // 2-10- 异常穿透
        // 2-11- catch:指定一个回调函数，该回调函数称为失败回调函数，当状态为失败时才会执行。
        //        p.catch(reason=>console.log(reason))等价于：p.then(null,reason=>console.log("resason",reason))
        // 2-12- 中断Promise链
        // const p = new Promise(function (resolve, reject) {
        //     reject(100);
        // })
        // const p1 =  p.then(value=>{
        //
        // },reason => {
        //     console.log("reason",reason);// 100
        //     return reason+1;
        // }).then(value=>{
        //     console.log("value",value);// 101
        //     return new Promise(()=>{})
        // }).then(value=>{
        //     console.log("value111",value);// 103
        //     throw value;
        // }).then(value=>{
        //     console.log("value111",value);
        // }).then(value=>{
        //     console.log("value",value);// 112
        //     throw value+1;
        // }).catch(reason=>{
        //     console.log("reason",reason);// 103
        //     return reason;
        // })
        // console.log("p1",p1)

    }
    {
        // 3- Promise的静态的方法：all race reject resolve
        // 特点1：返回的是一个Promise实例
        // 特点2：如果接收的是一个非Promise，那么得到的实例状态为成功，值为接收的值
        // 特点3：如果接收的是一个Promise，那么将接收的Promise实例直接返回
        // const p = new Promise((resolve,reject)=>{
        //     reject(2);
        // });
        // const p1 = Promise.resolve(p);
        // console.log(p1===p);// true

        // 4- reject
        // 特点1：返回的是一个失败的Promise实例，失败的值为接收的参数。
        const p = new Promise((resolve,reject)=>{
            reject(2);
        });
        const p1 = Promise.reject(p);
        p1.catch(reason=>{
            console.log(reason === p)
        })

    }


</script>
</html>